package com.gkzf.ai.module.crm.util.extracted;

import com.gkzf.ai.module.crm.util.YearlyRecord;
import lombok.extern.slf4j.Slf4j;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 *
 *         <table>
 *           <tr>
 *             <td>2020</td>
 *             <td>1</td>
 *             <td>2<br>0<br>*</td>
 *             <td>3<br>0<br>*</td>
 *             <td>4<br>0<br>C</td>
 *             <td>5</td>
 *             <td>6</td>
 *             <td>7</td>
 *             <td>8</td>
 *             <td>9</td>
 *             <td>10</td>
 *             <td>11</td>
 *             <td>12</td>
 *           </tr>
 *         </table>
 *         解析方法
 *
 */
@Slf4j
public class ParseMonthlySegments implements Extracted {

    // 正则表达式：匹配 <br> 标签 (可选斜杠，不区分大小写)
    // Pattern.CASE_INSENSITIVE 使其匹配 <BR>, <Br> 等
    private static final Pattern BR_TAG_PATTERN =
            Pattern.compile("<br\\s*/?>", Pattern.CASE_INSENSITIVE);
    @Override
    public Map<String, YearlyRecord> extractedData(String html, Set<String> SWAP_TRIGGER_CHARS) {
        Map<String, YearlyRecord> yearDataMap = new HashMap<>();

        // 对表格片段使用 parseBodyFragment
        Document doc = Jsoup.parseBodyFragment(html);

        // 选择所有表格行
        Elements rows = doc.select("tr");

        // 遍历行
        // 假设第一行就是数据行 (2020)
        // 如果你的实际数据有表头，需要调整循环起始索引
        for (int i = 0; i < rows.size(); i++) { // 从索引 0 开始处理第一行数据
            Element row = rows.get(i);
            Elements tds = row.select("td");


            // 第一个 td 是年份
            String year = tds.first().text().trim();

            // 为该年份创建一个新的 YearlyRecord
            YearlyRecord record = new YearlyRecord(year);

            // 遍历数据 td（从第二个 td 开始，即索引 1，直到第 13 个 td，索引 12）
            // 这对应于 12 个月份的数据
            for (int j = 1; j < tds.size(); j++) { // 从索引 1 开始
                Element td = tds.get(j);
                // 获取 td 的内部 HTML 内容以保留 <br> 标签
                String tdHtmlContent = td.html();
                // 根据需求，我们只需要 parts[1] (值2) 和 parts[2] (值3)
                String valueForList1 = ""; // 存储 parts[1] 的值，默认为空
                String valueForList2 = ""; // 存储 parts[2] 的值，默认为空
                if(countBrTagsRegex(tdHtmlContent) == 2) {
                    // 根据 <br> 分割内容 (不区分大小写，可选的空格/斜杠)
                    // limit 参数 -1 确保包含末尾的空字符串
                    String[] parts = tdHtmlContent.split("<br\\s*/?>", -1);



                    // 如果有至少2个分割部分 (即至少有一个 <br>), parts[1] 可能存在
                    if (parts.length > 1) {
                        // parts[1] 是第一个 <br> 和第二个 <br> 之间的值
                        valueForList1 = parts[1].trim().replaceAll("[\r\n]", "");
                    }

                    // 如果有至少3个分割部分 (即至少有两个 <br>), parts[2] 可能存在
                    if (parts.length > 2) {
                        // parts[2] 是第二个 <br> 后的值
                        valueForList2 = parts[2].trim().replaceAll("[\r\n]", "");
                    }
                }
                // 如果 parts.length > 3，后续的部分将被忽略，这符合只保存 parts[1] 和 parts[2] 的需求。

                // 将提取并清理后的值添加到记录的列表中
                // 注意：这里的 valueForList1 对应 YearlyRecord 的 list1
                //       这里的 valueForList2 对应 YearlyRecord 的 list2
                record.addDataPoint(valueForList1, valueForList2);
            }

            // --- 添加检查和互换逻辑 ---
            boolean shouldSwap = false;
            // 遍历 record.list1 中的每个值
            for (String value : record.getMonthList()) {
                try {
                    // 尝试将值解析为整数
                    int num = Integer.parseInt(value);
                    // 如果解析成功并且值大于 7
                    if (num > 7) {
                        shouldSwap = true; // 设置互换标志
                        break;             // 找到一个大于7的值就足够了，停止检查
                    }
                } catch (NumberFormatException e) {
                    // 如果值不是有效的数字，parseInt 会抛异常。
                    // 非数字的值不能大于 7，所以捕获异常后不做任何处理，继续检查下一个值。
                }
            }
            // --- 添加基于 list2 内容的检查和互换逻辑 ---
            // 遍历 record.list2 (它存储了原始的 Value3) 中的每个值
            for (String value : record.getMoneyList()) {
                // 检查值是否是我们定义的触发字符集合中的一个
                if (SWAP_TRIGGER_CHARS.contains(value)) {
                    shouldSwap = true; // 设置互换标志
                    break;             // 找到一个匹配的字符就足够了，停止检查
                }
            }

            // 如果需要互换
            if (shouldSwap) {
                log.info("年份 " + year + " 的数据需要互换 List1 和 List2 (List1中包含 > 7 的值)");
                // 互换 list1 和 list2 的内容
                List<String> temp = record.getMonthList();
                record.setMonthList(record.getMoneyList());
                record.setMoneyList(temp);
            }
            // --- 互换逻辑结束 ---


            // 将记录存储在 Map 中
            yearDataMap.put(year, record);
        }

        return yearDataMap;
    }



    /**
     * 匹配 <br>出现的次数
     * @param htmlContent
     * @return
     */
    public static int countBrTagsRegex(String htmlContent) {
        // 处理输入为 null 或空字符串的情况
        if (htmlContent == null || htmlContent.isEmpty()) {
            return 0;
        }

        int count = 0;
        // 创建一个匹配器来查找所有匹配 BR_TAG_PATTERN 的地方
        Matcher matcher = BR_TAG_PATTERN.matcher(htmlContent);

        // 循环查找匹配项，每找到一个，计数器加一
        while (matcher.find()) {
            count++;
        }

        return count;
    }
}
